I GRAFICI¶

In [ ]:
In [1]:
import matplotlib.pyplot as plt 
mese = ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio']
temperatura_media = [10, 12, 15, 18, 22]
plt.plot(mese, temperatura_media, marker='o', linestyle='--', color='lightpink')
plt.title('andamento delle temperature medie mensili')
plt.xlabel('mese')
plt.ylabel('temperatura media (°C)')
plt.grid(True, axis="y")
plt.show()
In [2]:
import matplotlib.pyplot as plt 
mese = ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio']
temperatura_media = [10, 12, 15, 18, 22]
plt.plot(mese, temperatura_media, marker='x', linestyle='-', color='lightgreen')
plt.title('andamento delle temperature medie mensili')
plt.xlabel('mese')
plt.ylabel('temperatura media (°C)')
plt.grid(True, axis="y")
plt.show()
In [3]:
vendite_mensili={
    "gen":1200,
    "feb":1000,
    "mar":3300,
    "apr":4555
}
plt.bar(vendite_mensili.keys(), vendite_mensili.values(), color="blue")
plt.show()
In [4]:
colori = ['gold', 'lightcoral', 'lightskyblue', 'lightgreen', 'pink']
mese = ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio']
temperatura_media = [10, 12, 15, 18, 22]
plt.pie(temperatura_media, labels=mese, colors=colori)
plt.title('percentuale di temperatura media mensile')
plt.show()
In [5]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

# Genera dati casuali per l'esplorazione
np.random.seed(42)
data = {
    'Età': np.random.randint(18, 70, size=1000),
    'Genere': np.random.choice(['Maschio', 'Femmina'], size=1000),
    'Punteggio': np.random.uniform(0, 100, size=1000),
     #random normal esce il numero con la media più alta, invece quella più bassa ha poca possibilità di uscire
    'Reddito': np.random.normal(50000, 15000, size=1000)
}

df = pd.DataFrame(data)

# Visualizza le prime righe del dataset
print(df.head())

   Età   Genere  Punteggio       Reddito
0   56  Maschio  85.120691  52915.764524
1   69  Maschio  49.514653  44702.505608
2   46  Maschio  48.058658  55077.257652
3   32  Femmina  59.240778  45568.978848
4   60  Maschio  82.468097  52526.914644
In [6]:
colori = ['gold', 'lightcoral', 'lightskyblue', 'lightgreen', 'pink']
temperatura_mesi={
    'gennaio': 10,
    'febbraio':12,
    'marzo':15,
    'aprile':18,
    'maggio':22
}
plt.pie(temperatura_mesi.values(), labels=temperatura_mesi.keys(), colors=colori)
plt.title('percentuale di temoeratura media mensile')
plt.show()
In [7]:
età = [14, 15, 16, 17, 18, 19]
altezza = [160, 165, 170, 175, 180, 185]
plt.scatter(età, altezza, color='red', marker='o')
plt.title('scatter plot - età vs altezza')
plt.xlabel('età')
plt.ylabel('altezza (cm)')
plt.grid(True, axis="y")
plt.show()
In [8]:
nomi_studenti = ['alice', 'bob', 'charlie', 'david', 'eve']
punteggi = [85, 92, 70, 88, 95]
plt.title('punteggi studenti')
plt.xlabel('punteggio')
plt.ylabel('nomi')
plt.barh(nomi_studenti, punteggi, color="blue")
plt.show()
In [9]:
import matplotlib.pyplot as plt
import pandas as pd

nomi_studenti = ['Alice', 'Bob', 'Charlie', 'David', 'Eve']
punteggi = [85, 92, 78, 88, 95]

# Crea un DataFrame con nomi e punteggi
data = {'Nome dello Studente': nomi_studenti, 'Punteggio': punteggi}
df = pd.DataFrame(data)
df.sort_values(by='Punteggio', inplace=True)
df
Out[9]:
Nome dello Studente Punteggio
2 Charlie 78
0 Alice 85
3 David 88
1 Bob 92
4 Eve 95
In [10]:
import matplotlib.pyplot as plt
import pandas as pd

nomi_studenti = ['Alice', 'Bob', 'Charlie', 'David', 'Eve']
punteggi = [85, 92, 78, 88, 95]

# Crea un DataFrame con nomi e punteggi
data = {'Nome dello Studente': nomi_studenti, 'Punteggio': punteggi}
df = pd.DataFrame(data)
df.sort_values(by='Punteggio', inplace=False)
plt.title('punteggi studenti')
plt.xlabel('punteggio')
plt.ylabel('nomi')
plt.barh(nomi_studenti, punteggi, color="blue")
plt.show()
df
Out[10]:
Nome dello Studente Punteggio
0 Alice 85
1 Bob 92
2 Charlie 78
3 David 88
4 Eve 95
In [11]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

# Genera dati casuali per l'esplorazione
np.random.seed(42)
data = {
    'Età': np.random.randint(18, 70, size=1000),
    'Genere': np.random.choice(['Maschio', 'Femmina'], size=1000),
    'Punteggio': np.random.uniform(0, 100, size=1000),
     #random normal esce il numero con la media più alta, invece quella più bassa ha poca possibilità di uscire
    'Reddito': np.random.normal(50000, 15000, size=1000)
}

df = pd.DataFrame(data)

# Visualizza le prime righe del dataset
print(df.head())

   Età   Genere  Punteggio       Reddito
0   56  Maschio  85.120691  52915.764524
1   69  Maschio  49.514653  44702.505608
2   46  Maschio  48.058658  55077.257652
3   32  Femmina  59.240778  45568.978848
4   60  Maschio  82.468097  52526.914644
In [12]:
import pandas as pd

# Dataset con dati mancanti rappresentati da None o NaN
dataset = [
    {"età": 25, "punteggio": 90, "ammesso": 1},
    {"età": None, "punteggio": 85, "ammesso": 0},
    {"età": 28, "punteggio": None, "ammesso": 1},
    {"età": None, "punteggio": 75, "ammesso": 1},
    {"età": 23, "punteggio": None, "ammesso": None},
    {"età": 23, "punteggio": 77, "ammesso": None},
]
df = pd.DataFrame(dataset)
df
Out[12]:
età punteggio ammesso
0 25.0 90.0 1.0
1 NaN 85.0 0.0
2 28.0 NaN 1.0
3 NaN 75.0 1.0
4 23.0 NaN NaN
5 23.0 77.0 NaN
In [13]:
df["punteggio"]
Out[13]:
0    90.0
1    85.0
2     NaN
3    75.0
4     NaN
5    77.0
Name: punteggio, dtype: float64
In [14]:
df["età"]
Out[14]:
0    25.0
1     NaN
2    28.0
3     NaN
4    23.0
5    23.0
Name: età, dtype: float64
In [15]:
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Genera dati di esempio
data = {
    'Feature1': [1, 2, np.nan, 4, 5],
    'Feature2': [np.nan, 2, 3, 4, np.nan],
    'Feature3': [1, np.nan, 3, 4, 5]
}

# Crea un DataFrame
df = pd.DataFrame(data)

# Calcola la matrice di missing values
missing_matrix = df.isnull()
missing_matrix
Out[15]:
Feature1 Feature2 Feature3
0 False True False
1 False False True
2 True False False
3 False False False
4 False True False
In [16]:
righe_con_dati_mancanti = df[df.isnull().any(axis=1)]
righe_con_dati_mancanti
Out[16]:
Feature1 Feature2 Feature3
0 1.0 NaN 1.0
1 2.0 2.0 NaN
2 NaN 3.0 3.0
4 5.0 NaN 5.0
In [17]:
totale_dati_mancanti = righe_con_dati_mancanti.shape[0]
totale_dati_mancanti
Out[17]:
4
In [18]:
totale_dati_mancanti = righe_con_dati_mancanti.shape[1]
totale_dati_mancanti
Out[18]:
3
In [19]:
print("righe con dati mancanti:")
print(righe_con_dati_mancanti)
print("totale dati mancanti: ", totale_dati_mancanti)

righe con dati mancanti:
   Feature1  Feature2  Feature3
0       1.0       NaN       1.0
1       2.0       2.0       NaN
2       NaN       3.0       3.0
4       5.0       NaN       5.0
totale dati mancanti:  3
In [20]:
import pandas as pd

# Dataset con dati mancanti rappresentati da None o NaN
dataset = [
    {"nome": "Alice", "età": 25, "punteggio": 90, "email": "alice@email.com"},
    {"nome": "Bob", "età": 22, "punteggio": None, "email": None},
    {"nome": "Charlie", "età": 28, "punteggio": 75, "email": "charlie@email.com"},
]

# Converti il dataset in un DataFrame
df = pd.DataFrame(dataset)
df
Out[20]:
nome età punteggio email
0 Alice 25 90.0 alice@email.com
1 Bob 22 NaN None
2 Charlie 28 75.0 charlie@email.com
In [21]:
df1=df.dropna(inplace=False)
df1
Out[21]:
nome età punteggio email
0 Alice 25 90.0 alice@email.com
2 Charlie 28 75.0 charlie@email.com
In [22]:
df.dropna(inplace=True)
df
Out[22]:
nome età punteggio email
0 Alice 25 90.0 alice@email.com
2 Charlie 28 75.0 charlie@email.com
In [23]:
# Crea una heatmap colorata
plt.figure(figsize=(8, 6))
#cbar serve per una barra di clore, False non lo voglio, Truese lo voglio
sns.heatmap(missing_matrix, cmap='viridis', cbar=True,alpha=0.8)
plt.title('Matrice di Missing Values')
plt.show
Out[23]:
<function matplotlib.pyplot.show(close=None, block=None)>
In [24]:
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt

# Genera dati di esempio
data = {
    'Variable1': [1, 2, 3, 4, 5],
    'Variable2': [1, 2, np.nan, 4, np.nan],
    'Missing_Column': ['A', 'B', 'A', 'C', np.nan]
}
# Crea un DataFrame
df = pd.DataFrame(data)
df1=pd.DataFrame()
df
Out[24]:
Variable1 Variable2 Missing_Column
0 1 1.0 A
1 2 2.0 B
2 3 NaN A
3 4 4.0 C
4 5 NaN NaN
In [25]:
numeric_cols = df.select_dtypes(include=['number'])
numeric_cols
Out[25]:
Variable1 Variable2
0 1 1.0
1 2 2.0
2 3 NaN
3 4 4.0
4 5 NaN
In [26]:
numeric_cols = df.select_dtypes(include=['number'])
numeric_cols.columns
Out[26]:
Index(['Variable1', 'Variable2'], dtype='object')
In [27]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

# Genera dati casuali per l'esplorazione
np.random.seed(42)
data = {
    'Età': np.random.randint(18, 70, size=1000),
    'Genere': np.random.choice(['Maschio', 'Femmina'], size=1000),
    'Punteggio': np.random.uniform(0, 100, size=1000),
     #random normal esce il numero con la media più alta, invece quella più bassa ha poca possibilità di uscire
    'Reddito': np.random.normal(50000, 15000, size=1000)
}

df = pd.DataFrame(data)

# Visualizza le prime righe del dataset
print(df.head())

   Età   Genere  Punteggio       Reddito
0   56  Maschio  85.120691  52915.764524
1   69  Maschio  49.514653  44702.505608
2   46  Maschio  48.058658  55077.257652
3   32  Femmina  59.240778  45568.978848
4   60  Maschio  82.468097  52526.914644
In [28]:
df = pd.DataFrame(data)
df1=pd.DataFrame()
df
Out[28]:
Età Genere Punteggio Reddito
0 56 Maschio 85.120691 52915.764524
1 69 Maschio 49.514653 44702.505608
2 46 Maschio 48.058658 55077.257652
3 32 Femmina 59.240778 45568.978848
4 60 Maschio 82.468097 52526.914644
... ... ... ... ...
995 60 Femmina 1.260752 28916.494712
996 64 Maschio 55.975568 50234.275009
997 62 Femmina 52.739962 63534.157607
998 35 Maschio 71.935362 36383.657298
999 55 Maschio 89.025805 72789.258855

1000 rows × 4 columns

In [29]:
categorical_cols = df.select_dtypes(exclude=['number'])
categorical_cols.columns
Out[29]:
Index(['Genere'], dtype='object')
In [30]:
import plotly.express as px 
fig = px.scatter(df, x='Età', y='Reddito', color='Genere', size='Punteggio')
fig.update_layout(title='grafico a dispersione interattivo')
fig.show()
In [31]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Genera dati casuali per l'esplorazione
np.random.seed(42)
data = {
    'Data': pd.date_range(start='2023-01-01', end='2023-12-31', freq='D'),
    'Vendite': np.random.randint(100, 1000, size=365),
    'Prodotto': np.random.choice(['A', 'B', 'C'], size=365)
}

df = pd.DataFrame(data)

# Visualizza le prime righe del dataset
print(df.head())
# Visualizza un grafico delle vendite nel tempo
plt.figure(figsize=(12, 6))
sns.lineplot(x='Data', y='Vendite', data=df)
plt.title('Andamento delle vendite nel tempo')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.xticks(rotation=45)
plt.show()

# Visualizza una box plot delle vendite per prodotto
plt.figure(figsize=(10, 6))
sns.boxplot(x='Prodotto', y='Vendite', data=df)
plt.title('Box Plot delle vendite per prodotto')
plt.xlabel('Prodotto')
plt.ylabel('Vendite')
plt.show()

        Data  Vendite Prodotto
0 2023-01-01      202        B
1 2023-01-02      535        A
2 2023-01-03      960        C
3 2023-01-04      370        A
4 2023-01-05      206        A
In [32]:
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

# Genera dati di esempio
data = {
    'Numeric_Var': [1, 2, 3, 4, np.nan, 6],
    'Categorical_Var': ['A', 'B', 'A', 'B', 'A', 'B']
}

# Crea un DataFrame
df = pd.DataFrame(data)
print(df)

   Numeric_Var Categorical_Var
0          1.0               A
1          2.0               B
2          3.0               A
3          4.0               B
4          NaN               A
5          6.0               B
In [33]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Genera dati casuali per l'esplorazione
np.random.seed(42)
data = {
    'Età': np.random.randint(18, 65, size=500),
    'Soddisfazione': np.random.choice(['Molto Soddisfatto', 'Soddisfatto', 'Neutro', 'Insoddisfatto', 'Molto Insoddisfatto'], size=500)
}

df = pd.DataFrame(data)
print(df)
conditional_means = df.groupby('Soddisfazione')['Età'].transform('mean')

df['Numeric_Var'] = conditional_means
print(df)

# Crea un grafico a barre per mostrare la media condizionata per ogni categoria
plt.figure(figsize=(8, 6))
sns.barplot(data=df, x='Soddisfazione', y='Numeric_Var', errorbar=None)
plt.xlabel('Soddisfazione')
plt.ylabel('Media Condizionata di Numeric_Var')
plt.title('Media Condizionata delle Variabili Numeriche per Categoria')
plt.xticks(rotation=90)

plt.show()

     Età        Soddisfazione
0     56    Molto Soddisfatto
1     46  Molto Insoddisfatto
2     32               Neutro
3     60               Neutro
4     25  Molto Insoddisfatto
..   ...                  ...
495   37    Molto Soddisfatto
496   41    Molto Soddisfatto
497   29    Molto Soddisfatto
498   52    Molto Soddisfatto
499   50    Molto Soddisfatto

[500 rows x 2 columns]
     Età        Soddisfazione  Numeric_Var
0     56    Molto Soddisfatto    41.651376
1     46  Molto Insoddisfatto    40.054054
2     32               Neutro    41.747368
3     60               Neutro    41.747368
4     25  Molto Insoddisfatto    40.054054
..   ...                  ...          ...
495   37    Molto Soddisfatto    41.651376
496   41    Molto Soddisfatto    41.651376
497   29    Molto Soddisfatto    41.651376
498   52    Molto Soddisfatto    41.651376
499   50    Molto Soddisfatto    41.651376

[500 rows x 3 columns]
In [34]:
# Visualizza le prime righe del dataset
print(df.head())

# Visualizza una distribuzione dell'età
plt.figure(figsize=(10, 6))
sns.histplot(df['Età'], bins=50, kde=True)
plt.title('Distribuzione dell\'età dei partecipanti al sondaggio')
plt.xlabel('Età')
plt.ylabel('Conteggio')
plt.show()

# Visualizza un conteggio delle risposte sulla soddisfazione
plt.figure(figsize=(8, 6))
sns.countplot(x='Soddisfazione', data=df, order=['Molto Soddisfatto', 'Soddisfatto', 'Neutro', 'Insoddisfatto', 'Molto Insoddisfatto'])
plt.title('Conteggio delle risposte sulla soddisfazione')
plt.xlabel('Soddisfazione')
plt.ylabel('Conteggio')
plt.xticks(rotation=45)
plt.show()

   Età        Soddisfazione  Numeric_Var
0   56    Molto Soddisfatto    41.651376
1   46  Molto Insoddisfatto    40.054054
2   32               Neutro    41.747368
3   60               Neutro    41.747368
4   25  Molto Insoddisfatto    40.054054
In [35]:
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

# Genera un dataset di esempio con variabili numeriche
np.random.seed(42)
data = pd.DataFrame(np.random.rand(100, 5), columns=['Var1', 'Var2', 'Var3', 'Var4', 'Var5'])

# Aggiungi alcune variabili categoriche generate casualmente
data['Categoria1'] = np.random.choice(['A', 'B', 'C'], size=100)
data['Categoria2'] = np.random.choice(['X', 'Y'], size=100)
# Calcola la matrice di correlazione tra tutte le variabili numeriche
correlation_matrix = data.corr()

# Visualizza la matrice di correlazione come heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f",alpha=0.7)
plt.title("Matrice di Correlazione")
plt.show()

C:\Users\joele\AppData\Local\Temp\ipykernel_21244\269467967.py:13: FutureWarning:

The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.
In [36]:
import pandas as pd
import numpy as np

# Impostare il seed per rendere i risultati riproducibili
np.random.seed(41)

# Creare un dataframe vuoto
df = pd.DataFrame()

# Generare dati casuali
n_rows = 10000
df['CatCol1'] = np.random.choice(['A', 'B', 'C'], size=n_rows)
df['CatCol2'] = np.random.choice(['X', 'Y'], size=n_rows)
df['NumCol1'] = np.random.randn(n_rows)
df['NumCol2'] = np.random.randint(1, 100, size=n_rows)
df['NumCol3'] = np.random.uniform(0, 1, size=n_rows)

# Calcolare il numero totale di missing values desiderati
total_missing_values = int(0.03 * n_rows * len(df.columns))

# Introdurre missing values casuali
for column in df.columns:
    num_missing_values = np.random.randint(0, total_missing_values + 1)
    missing_indices = np.random.choice(n_rows, size=num_missing_values, replace=False)
    df.loc[missing_indices, column] = np.nan
df
Out[36]:
CatCol1 CatCol2 NumCol1 NumCol2 NumCol3
0 A NaN 0.440877 49.0 0.246007
1 A Y 1.945879 28.0 0.936825
2 C X 0.988834 42.0 0.751516
3 A Y -0.181978 73.0 0.950696
4 B X 2.080615 74.0 0.903045
... ... ... ... ... ...
9995 C Y 1.352114 61.0 0.728445
9996 C Y 1.143642 67.0 0.605930
9997 A X -0.665794 54.0 0.071041
9998 C Y 0.004278 NaN NaN
9999 A X 0.622473 95.0 0.751384

10000 rows × 5 columns

In [37]:
righe_con_dati_mancanti = df[df.isnull().any(axis=1)]
len(righe_con_dati_mancanti)
Out[37]:
3648
In [38]:
missing_percent = (df.isnull().sum() / len(df)) * 100
missing_percent
Out[38]:
CatCol1     0.29
CatCol2    10.63
NumCol1     9.67
NumCol2    10.48
NumCol3    12.69
dtype: float64
In [39]:
missing_percent = (df.isnull().sum() / len(df)) *100

# Crea il grafico a barre
plt.figure(figsize=(10, 6))
missing_percent.plot(kind='bar', color='skyblue',alpha=0.8)
plt.xlabel('Variabili')
plt.ylabel('Percentuale di Missing Values')
plt.title('Analisi dei Missing Values per Variabile')
plt.xticks(rotation=0)
plt.show()
In [40]:
numeric_features = df.select_dtypes(include=[np.number])
sns.pairplot(df[numeric_features.columns])
plt.title('Matrice di Scatter Plot tra variabili numeriche')
plt.show
Out[40]:
<function matplotlib.pyplot.show(close=None, block=None)>
In [41]:
df = df.dropna(subset=['NumCol1', 'NumCol2', 'NumCol3'], how='all' )
df
Out[41]:
CatCol1 CatCol2 NumCol1 NumCol2 NumCol3
0 A NaN 0.440877 49.0 0.246007
1 A Y 1.945879 28.0 0.936825
2 C X 0.988834 42.0 0.751516
3 A Y -0.181978 73.0 0.950696
4 B X 2.080615 74.0 0.903045
... ... ... ... ... ...
9995 C Y 1.352114 61.0 0.728445
9996 C Y 1.143642 67.0 0.605930
9997 A X -0.665794 54.0 0.071041
9998 C Y 0.004278 NaN NaN
9999 A X 0.622473 95.0 0.751384

9980 rows × 5 columns

In [42]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
percorso_file_csv = "C:\\Users\\joele\\OneDrive\\Desktop\\dati robotica\\pokemons.csv"
df = pd.read_csv(percorso_file_csv)
print(df.head())

   id        name      rank    generation evolves_from  type1   type2  hp  \
0   1   bulbasaur  ordinary  generation-i      nothing  grass  poison  45   
1   2     ivysaur  ordinary  generation-i    bulbasaur  grass  poison  60   
2   3    venusaur  ordinary  generation-i      ivysaur  grass  poison  80   
3   4  charmander  ordinary  generation-i      nothing   fire    None  39   
4   5  charmeleon  ordinary  generation-i   charmander   fire    None  58   

   atk  def  spatk  spdef  speed  total  height  weight  \
0   49   49     65     65     45    318       7      69   
1   62   63     80     80     60    405      10     130   
2   82   83    100    100     80    525      20    1000   
3   52   43     60     50     65    309       6      85   
4   64   58     80     65     80    405      11     190   

               abilities                                               desc  
0  overgrow chlorophyll   A strange seed was planted on its back at birt...  
1  overgrow chlorophyll   When the bulb on its back grows large, it appe...  
2  overgrow chlorophyll   The plant blooms when it is absorbing solar en...  
3     blaze solar-power   Obviously prefers hot places. When it rains, s...  
4     blaze solar-power   When it swings its burning tail, it elevates t...
In [43]:
import pandas as pd

percorso_file_excel = "C:\\Users\\joele\\OneDrive\\Desktop\\dati robotica\\serieA.xlsx"
df = pd.read_excel(percorso_file_excel , sheet_name='10-11')
df
Out[43]:
position team Pt Played Won Net lose Goals made Goals suffered Difference goals
0 1 Milan Milan 82 38 24 10 4 65 24 41
1 2 Inter Inter 76 38 23 7 8 69 42 27
2 3 Napoli Napoli 70 38 21 7 10 59 39 20
3 4 Udinese Udinese 66 38 20 6 12 65 43 22
4 5 Lazio Lazio 66 38 20 6 12 55 39 16
5 6 Roma Roma 63 38 18 9 11 59 52 7
6 7 Juventus Juventus 58 38 15 13 10 57 47 10
7 8 Palermo Palermo 56 38 17 5 16 58 63 -5
8 9 Fiorentina Fiorentina 51 38 12 15 11 49 44 5
9 10 Genoa Genoa 51 38 14 9 15 45 47 -2
10 11 Chievo Chievo 46 38 11 13 14 38 40 -2
11 12 Parma Parma 46 38 11 13 14 39 47 -8
12 13 Catania Catania 46 38 12 10 16 40 52 -12
13 14 Cagliari Cagliari 45 38 12 9 17 44 51 -7
14 15 Cesena Cesena 43 38 11 10 17 38 50 -12
15 16 Bologna Bologna (-3) 42 38 11 12 15 35 52 -17
16 17 Lecce Lecce 41 38 11 8 19 46 66 -20
17 18 Sampdoria Sampdoria 36 38 8 12 18 33 49 -16
18 19 Brescia Brescia 32 38 7 11 20 34 52 -18
19 20 Bari Bari 24 38 5 9 24 27 56 -29
In [47]:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

# Creazione di dati casuali per visite al sito web e importo delle vendite
np.random.seed(0)
visite_al_sito = np.random.randint(100, 1000, 1000)
importo_vendite = 50 + 0.2 * visite_al_sito + np.random.normal(0, 10, 1000)

# Suddivisione del dataset in training set (70%) e test set (30%)
X_train, X_test, y_train, y_test = train_test_split(visite_al_sito, importo_vendite, test_size=0.3, random_state=42)

# Creazione di un grafico a dispersione
plt.figure(figsize=(10, 6))
plt.scatter(X_train, y_train, label='Training Set', color='blue', alpha=0.7)
plt.scatter(X_test, y_test, label='Test Set', color='orange', alpha=0.7)
plt.xlabel('Numero di Visite al Sito')
plt.ylabel('Importo delle Vendite')
plt.title('Relazione tra Visite al Sito e Importo delle Vendite')
plt.legend()
plt.grid(True)
plt.show()

# Stampare le dimensioni dei training set e test set
print("Dimensioni del Training Set (visite al sito e importo delle vendite):", X_train.shape, y_train.shape)
print("Dimensioni del Test Set (visite al sito e importo delle vendite):", X_test.shape, y_test.shape)

Dimensioni del Training Set (visite al sito e importo delle vendite): (700,) (700,)
Dimensioni del Test Set (visite al sito e importo delle vendite): (300,) (300,)
In [ ]:
In [ ]: